import { showLoadingToSuccess } from '../../utils/util';

// 任务状态类型
type TaskStatus = 'PENDING' | 'RUNNING' | 'SUCCEEDED' | 'FAILED';

interface TaskResult {
  success: boolean;
  status?: TaskStatus;
  results?: Array<{url: string}>;
  taskId?: string;
  message?: string;
  error?: any;
}

Page({
  data: {
    taskId: '',
    prompt: '',
    negativePrompt: '',
    isLoading: true,
    generatedImage: '',
    status: '' as TaskStatus,
    errorMsg: '',
    // 轮询相关
    pollingTimer: null as number | null,
    pollingCount: 0,
    maxPollingCount: 60, // 最大轮询次数（约10分钟）
    debugInfo: '', // 用于调试
    isPublishing: false // 防止重复发布
  },

  onLoad(options: { taskId: string; prompt: string; negativePrompt?: string }) {
    if (options.taskId && options.prompt) {
      const taskId = options.taskId;
      const prompt = decodeURIComponent(options.prompt);
      const negativePrompt = options.negativePrompt ? decodeURIComponent(options.negativePrompt) : '';
      
      this.setData({
        taskId,
        prompt,
        negativePrompt,
        isLoading: true,
        debugInfo: `任务ID: ${taskId}`
      });
      
      console.log('图片结果页面加载', { taskId, prompt });
      
      // 开始查询任务状态
      this.startPollingTaskStatus();
    } else {
      wx.showToast({
        title: '参数错误',
        icon: 'error'
      });
      setTimeout(() => {
        wx.navigateBack();
      }, 1500);
    }
  },

  onUnload() {
    // 离开页面时清除定时器
    this.clearPollingTimer();
  },

  // 开始轮询任务状态
  startPollingTaskStatus() {
    console.log('开始轮询任务状态');
    // 先立即查询一次
    this.checkTaskStatus();
    
    // 然后每5秒查询一次任务状态（改为更频繁地查询）
    const timer = setInterval(() => {
      this.checkTaskStatus();
    }, 5000);
    
    this.setData({
      pollingTimer: timer as unknown as number
    });
  },

  // 清除轮询定时器
  clearPollingTimer() {
    console.log('清除轮询定时器');
    if (this.data.pollingTimer) {
      clearInterval(this.data.pollingTimer);
      this.setData({
        pollingTimer: null
      });
    }
  },

  // 检查任务状态
  checkTaskStatus() {
    if (!this.data.taskId) return;
    
    // 如果已经达到最大轮询次数
    if (this.data.pollingCount >= this.data.maxPollingCount) {
      this.clearPollingTimer();
      this.setData({
        isLoading: false,
        errorMsg: '生成超时，请重试'
      });
      return;
    }
    
    const self = this;
    console.log(`开始第${this.data.pollingCount + 1}次查询任务状态`, this.data.taskId);
    
    // 使用回调方式调用云函数
    wx.cloud.callFunction({
      name: 'imageGenerator',
      data: {
        action: 'getTaskResult',
        data: {
          taskId: this.data.taskId
        }
      },
      success(res) {
        console.log('查询任务状态成功', res);
        // @ts-ignore
        const result = res.result as TaskResult;
        
        // 检查API调用是否成功
        if (!result) {
          console.error('查询任务状态返回为空');
          self.setData({
            pollingCount: self.data.pollingCount + 1,
            debugInfo: `轮询次数: ${self.data.pollingCount + 1}, 返回为空`
          });
          return;
        }
        
        // 检查API结果中是否有Aliyun API的结果
        if (!result.success) {
          const errorMsg = result.message || '查询任务状态失败';
          console.error('查询任务状态返回失败', { result, errorMsg });
          
          if (errorMsg.includes('database collection not exists') || 
              errorMsg.includes('DATABASE_COLLECTION_NOT_EXIST')) {
            // 如果是数据库集合不存在的错误，继续轮询
            console.log('数据库集合不存在，可以忽略，继续轮询');
          }
          
          self.setData({
            pollingCount: self.data.pollingCount + 1,
            debugInfo: `轮询次数: ${self.data.pollingCount + 1}, 错误: ${errorMsg.substring(0, 50)}...`
          });
          return;
        }
        
        const status = result.status as TaskStatus;
        console.log('任务状态', { status, result });
        
        self.setData({
          status,
          pollingCount: self.data.pollingCount + 1,
          debugInfo: `轮询次数: ${self.data.pollingCount + 1}, 状态: ${status}`
        });
        
        // 如果任务已经完成
        if (status === 'SUCCEEDED' && result.results && result.results.length > 0) {
          console.log('任务成功完成', result.results[0]);
          self.setData({
            isLoading: false,
            generatedImage: result.results[0].url
          });
          
          // 任务完成，清除定时器
          self.clearPollingTimer();
        } 
        // 如果任务失败
        else if (status === 'FAILED') {
          console.error('任务失败', result);
          self.clearPollingTimer();
          self.setData({
            isLoading: false,
            errorMsg: '生成失败，请重试'
          });
        }
        // 如果仍在进行中，继续轮询
        else {
          console.log('任务进行中，继续轮询');
        }
      },
      fail(err) {
        console.error('调用查询任务云函数失败:', err);
        // 查询失败不代表任务失败，继续轮询
        self.setData({
          pollingCount: self.data.pollingCount + 1,
          debugInfo: `轮询次数: ${self.data.pollingCount + 1}, 云函数调用失败`
        });
      }
    });
  },

  previewImage() {
    if (!this.data.generatedImage) return;
    
    wx.previewImage({
      urls: [this.data.generatedImage],
      current: this.data.generatedImage
    });
  },

  onRegenerateImage() {
    console.log('开始重新生成图片');
    this.setData({ 
      isLoading: true,
      generatedImage: '',
      errorMsg: '',
      pollingCount: 0,
      debugInfo: '重新生成中...'
    });
    
    const self = this;
    // 使用回调方式调用云函数
    wx.cloud.callFunction({
      name: 'imageGenerator',
      data: {
        action: 'createImageTask',
        data: {
          prompt: this.data.prompt,
          negativePrompt: this.data.negativePrompt || '',
          size: '1024*1024',
          n: 1
        }
      },
      success(res) {
        console.log('创建图像任务成功', res);
        // @ts-ignore
        const result = res.result as TaskResult;
        
        if (!result || !result.success || !result.taskId) {
          const errorMsg = result?.message || '创建任务失败';
          console.error('创建图像任务返回失败', { result, errorMsg });
          
          wx.showToast({
            title: errorMsg.length > 7 ? errorMsg.substring(0, 7) + '...' : errorMsg,
            icon: 'error'
          });
          self.setData({
            isLoading: false,
            errorMsg: errorMsg,
            debugInfo: `创建失败: ${errorMsg}`
          });
          return;
        }
        
        self.setData({
          taskId: result.taskId,
          debugInfo: `新任务ID: ${result.taskId}`
        });
        
        // 开始查询任务状态
        self.startPollingTaskStatus();
      },
      fail(err) {
        console.error('调用创建图像任务云函数失败:', err);
        self.setData({
          isLoading: false,
          errorMsg: '重新生成失败，请重试',
          debugInfo: '云函数调用失败'
        });
      }
    });
  },

  onPublishImage() {
    // 防止重复点击
    if (this.data.isPublishing) {
      return;
    }

    // 设置发布状态为true
    this.setData({
      isPublishing: true
    });

    showLoadingToSuccess('发布中...', '正在发布').then(() => {
      if (!this.data.taskId || !this.data.generatedImage) {
        wx.showToast({
          title: '图片未生成',
          icon: 'error'
        });
        // 重置发布状态
        this.setData({
          isPublishing: false
        });
        return;
      }

      // 调试显示图片URL类型
      console.log('准备发布图片', {
        imageUrl: this.data.generatedImage,
        isCloudStorage: this.data.generatedImage.startsWith('cloud://'),
        isHttps: this.data.generatedImage.startsWith('https://')
      });

      this.setData({
        debugInfo: '正在发布图片...'
      });

      // 调用发布图片云函数
      wx.cloud.callFunction({
        name: 'publishImage',
        data: {
          imageUrl: this.data.generatedImage,
          prompt: this.data.prompt,
          taskId: this.data.taskId
        },
        success: (res) => {
          console.log('发布图片成功', res);
          // @ts-ignore
          const result = res.result as { 
            success: boolean; 
            message?: string; 
            imageId?: string; 
            fileID?: string;
            prompt?: string;
            userInfo?: {
              nickName: string;
              avatarUrl: string;
            }
          };

          if (result && result.success) {
            // 发布成功
            wx.showToast({
              title: '发布成功',
              icon: 'success'
            });

            // 创建新发布的图片对象，用于在首页显示
            const app = getApp<{
              globalData: {
                newPublishedImage?: {
                  id: string;
                  prompt: string;
                  imageUrl: string;
                  createdAt: number;
                  user?: {
                    nickName: string;
                    avatarUrl: string;
                  }
                };
                userInfo: any;
              };
            }>();
            
            // 保存新发布的图片到全局数据
            app.globalData.newPublishedImage = {
              id: result.imageId || '',
              prompt: result.prompt || this.data.prompt,
              imageUrl: result.fileID || this.data.generatedImage,
              createdAt: Date.now(),
              user: result.userInfo || {
                nickName: app.globalData.userInfo?.nickName || '未知用户',
                avatarUrl: app.globalData.userInfo?.avatarUrl || ''
              }
            };

            // 跳转到首页展示作品
            setTimeout(() => {
              // 首先获取当前页面
              const pages = getCurrentPages();
              // 检查是否有首页实例
              let homePage = null;
              for (let i = 0; i < pages.length; i++) {
                if (pages[i].route === 'pages/home/index') {
                  homePage = pages[i];
                  break;
                }
              }
              
              // 如果找到首页，强制重新加载数据
              if (homePage) {
                // @ts-ignore 调用首页的刷新方法
                homePage.setData({
                  page: 1,
                  imageList: [],
                  leftColumn: [],
                  rightColumn: [],
                  hasMore: true
                });
                // @ts-ignore
                homePage.loadImagesFromCloud();
              }
              
              // 切换到首页标签
              wx.switchTab({
                url: '/pages/home/index'
              });
            }, 1500);
          } else {
            // 发布失败
            wx.showToast({
              title: result?.message || '发布失败',
              icon: 'error'
            });
            // 重置发布状态
            this.setData({
              isPublishing: false
            });
          }
        },
        fail: (err) => {
          console.error('调用发布图片云函数失败', err);
          wx.showToast({
            title: '发布失败',
            icon: 'error'
          });
          // 重置发布状态
          this.setData({
            isPublishing: false
          });
        }
      });
    });
  }
}); 